Course: Core Java Training
Topic: Implementing the Runnable Interface
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
JustAcademy Website: Visit JustAcademy
Java supports multithreading, which allows multiple threads to make progress concurrently within a program. One common way to define a task for a thread is to implement the Runnable interface.
The Runnable interface belongs to the java.lang package and represents a task that can be executed by a thread. It defines a single abstract method named run(). A class that implements Runnable provides the code that should execute when the task runs.
Implementing Runnable separates the task's logic from the thread that executes it. Instead of extending the Thread class, a class can implement Runnable and pass its object to a Thread instance. This approach is especially useful when a class already extends another class or when the same task needs to be submitted to different execution mechanisms.
Runnable interface.run() method.Runnable object.start() and run().Runnable with extending Thread.Runnable.Runnable interface in practical Java programs.Runnable is a functional interface used to represent an operation that does not return a result. Its main method is:
public interface Runnable {
void run();
}The interface is annotated with @FunctionalInterface in the Java API, which means it has one abstract method and can be implemented using a lambda expression or method reference.
When a Runnable object is supplied to a Thread and that thread is started, the task's run() method is invoked in the new thread of execution.
java.langrun()voidRunnable object alone does not start a new thread.Java allows a class to extend only one class. If a class extends Thread, it cannot extend another class at the same time. Implementing Runnable avoids this limitation because a class can implement interfaces while extending a class.
Another important benefit is separation of concerns. The task contains the business logic, while the Thread object manages the execution thread. The task can also be reused with executor services and thread pools.
Follow these steps to create and execute a thread using Runnable:
Runnable.run() method with the task's logic.Thread constructor.start() on the thread object.The following program demonstrates a simple task that prints a message from a separate thread.
class MyTask implements Runnable {
@Override
public void run() {
System.out.println("Task is running in a separate thread");
}
}
public class Main {
public static void main(String[] args) {
MyTask task = new MyTask();
Thread thread = new Thread(task);
thread.start();
}
}Output:
Task is running in a separate threadMyTask implements the Runnable interface.run() method contains the task to execute.new MyTask() creates the task object.new Thread(task) creates a thread configured to execute the task.thread.start() starts the new thread, which then invokes the task's run() method.A Runnable task can contain loops, calculations, method calls, or other application logic just like an ordinary Java method.
class NumberPrinter implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Number: " + i);
}
}
}
public class Main {
public static void main(String[] args) {
NumberPrinter task = new NumberPrinter();
Thread thread = new Thread(task);
thread.start();
}
}Output:
Number: 1
Number: 2
Number: 3
Number: 4
Number: 5This output is typical for this single task, but when several threads print simultaneously, their output can interleave in different orders depending on scheduling.
The same Runnable implementation can be used to create multiple thread objects. Each thread independently executes the task, although shared objects or variables used by those tasks may require synchronization.
class Worker implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println(
Thread.currentThread().getName() + " - " + i
);
}
}
}
public class Main {
public static void main(String[] args) {
Worker task = new Worker();
Thread first = new Thread(task, "Worker-A");
Thread second = new Thread(task, "Worker-B");
first.start();
second.start();
}
}Possible output:
Worker-A - 1
Worker-B - 1
Worker-A - 2
Worker-B - 2
Worker-B - 3
Worker-A - 3The actual order may differ. Both threads execute the same task object. This is safe in this example because the task does not maintain mutable instance state; if a shared task modifies common data, appropriate thread-safety measures may be necessary.
Understanding the difference between start() and run() is essential when working with the Runnable interface.
| Feature | start() | run() |
|---|---|---|
| Purpose | Starts a new thread of execution. | Contains or invokes the task's execution logic. |
| Thread behavior | Schedules execution on a separate thread. | A direct method call executes on the calling thread. |
| JVM behavior | The new thread invokes its target's run() method. |
Does not itself create a new thread. |
| Typical use | Call it on a newly created Thread. |
Override it in a task or call it indirectly through a thread. |
class MyTask implements Runnable {
@Override
public void run() {
System.out.println(
"Executing on: " + Thread.currentThread().getName()
);
}
}
public class Main {
public static void main(String[] args) {
MyTask task = new MyTask();
task.run();
Thread thread = new Thread(task, "Background-Worker");
thread.start();
}
}Possible output:
Executing on: main
Executing on: Background-WorkerThe direct call to task.run() runs on the main thread. The call to thread.start() runs the task on a separate thread.
Because Runnable is a functional interface, Java allows a lambda expression to provide the implementation of its single abstract method. This approach is concise and common in modern Java applications.
public class Main {
public static void main(String[] args) {
Runnable task = () -> {
System.out.println("Runnable using a lambda expression");
};
Thread thread = new Thread(task);
thread.start();
}
}Output:
Runnable using a lambda expressionThe lambda expression acts as the implementation of run(). It does not create or start a thread by itself; the Thread object and its start() method provide the separate execution.
An anonymous class can implement Runnable without declaring a separate named class. This style is useful when the task is small and only needed in one location.
public class Main {
public static void main(String[] args) {
Runnable task = new Runnable() {
@Override
public void run() {
System.out.println("Task from anonymous class");
}
};
new Thread(task).start();
}
}Output:
Task from anonymous classFor short tasks, a lambda expression is usually more concise. Anonymous classes remain useful when the implementation requires additional methods or more complex class behavior.
A method reference can be used when an existing method matches the signature required by Runnable. For example, a method that takes no arguments and returns void can be referenced as a task.
public class Main {
static void printMessage() {
System.out.println("Executing an existing method");
}
public static void main(String[] args) {
Runnable task = Main::printMessage;
Thread thread = new Thread(task);
thread.start();
}
}Output:
Executing an existing methodThe method reference Main::printMessage supplies the implementation for run(). The method executes on the thread that runs the task.
Java offers two common approaches for defining thread tasks: implementing Runnable and extending Thread. They are related, but they represent different design choices.
| Feature | Implementing Runnable | Extending Thread |
|---|---|---|
| Relationship | Defines a task that can be executed by a thread. | Defines a specialized thread class. |
| Inheritance | The class can extend another class. | The class already extends Thread. |
| Task reuse | The same task can be passed to multiple thread objects or execution frameworks. | The task is coupled to the thread subclass. |
| Thread management | Separate from the task implementation. | Combined with the subclass. |
| Lambda support | Yes, because Runnable is a functional interface. |
A subclass of Thread is not itself a functional interface. |
| Recommended use | Usually preferred when defining task logic. | Useful when genuinely customizing thread behavior. |
The sleep() method pauses the currently executing thread for a specified time. It is often used in demonstrations, timed tasks, and simple simulations. It does not release monitor locks that the current thread holds.
class TimerTaskExample implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println("Count: " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.out.println("Task interrupted");
return;
}
}
}
}
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new TimerTaskExample());
thread.start();
}
}Output:
Count: 1
Count: 2
Count: 3The values are printed approximately one second apart. The sleep duration is not a guarantee of exact scheduling time. The example also restores the interrupt status and exits the task if an interruption occurs.
The run() method does not declare checked exceptions in its method signature. Therefore, checked exceptions raised inside the task must be caught and handled within the implementation or converted into an appropriate unchecked exception.
class FileProcessingTask implements Runnable {
@Override
public void run() {
try {
processFile();
} catch (java.io.IOException e) {
System.err.println("File processing failed: " + e.getMessage());
}
}
private void processFile() throws java.io.IOException {
System.out.println("Processing file...");
// File-processing logic would be placed here.
}
}
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new FileProcessingTask());
thread.start();
}
}Output:
Processing file...In this example, processFile() declares that it may throw IOException, so the task handles that checked exception inside run(). In production applications, exception handling should also record useful diagnostic information and communicate failures to the appropriate application layer.
Implementing Runnable does not automatically make a task thread-safe. If multiple threads access and modify the same mutable object, race conditions may occur unless access is coordinated correctly.
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
class CounterTask implements Runnable {
private final Counter counter;
CounterTask(Counter counter) {
this.counter = counter;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread first = new Thread(new CounterTask(counter));
Thread second = new Thread(new CounterTask(counter));
first.start();
second.start();
first.join();
second.join();
System.out.println(counter.getCount());
}
}Output:
2000The two tasks share the same Counter object. Its synchronized methods protect the shared counter from lost updates, and the calls to join() ensure both threads complete before the final value is read.
In real applications, creating a new thread manually for every task may be inefficient. Java's executor framework allows tasks to be submitted to a thread pool, which manages thread creation and reuse.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
Runnable task = () -> {
System.out.println(
"Task executed by " + Thread.currentThread().getName()
);
};
executor.submit(task);
executor.submit(task);
executor.shutdown();
}
}Possible output:
Task executed by pool-1-thread-1
Task executed by pool-1-thread-2The actual thread names and execution order may vary. The executor schedules submitted tasks using its available worker threads. Calling shutdown() stops accepting new tasks while allowing previously submitted tasks to complete.
Note: If an application needs to wait until all submitted tasks have completed, it can use awaitTermination(), futures, or another coordination mechanism.
Runnable is designed for a task that does not return a result. If a task needs to return a value or declare a checked exception through its method signature, Java provides the Callable<V> interface.
| Feature | Runnable | Callable |
|---|---|---|
| Method | run() |
call() |
| Return value | No return value; return type is void. |
Returns a value of type V. |
| Checked exceptions | Cannot declare checked exceptions in run(). |
call() can declare checked exceptions. |
| Typical use | Tasks such as logging, sending messages, or updating data. | Tasks that calculate and return results. |
| Executor usage | Can be submitted to an executor. | Can be submitted to an executor to obtain a Future result. |
| Mistake | Why It Is a Problem | Correct Approach |
|---|---|---|
Calling run() directly |
The task executes on the current thread. | Pass the task to a Thread and call start(). |
| Assuming Runnable starts a thread automatically | The interface only defines task behavior. | Use a Thread or an executor service to run it. |
| Ignoring interruption | Tasks may fail to stop when cancellation is requested. | Handle InterruptedException and restore interrupt status when appropriate. |
| Sharing mutable data without protection | Concurrent modifications can produce inconsistent results. | Use synchronization, locks, atomic variables, or concurrent collections as appropriate. |
| Assuming a fixed output order | Thread scheduling is nondeterministic. | Use explicit coordination when ordering matters. |
| Creating too many threads | Excessive threads consume resources and increase scheduling overhead. | Consider a suitable executor or thread pool. |
| Swallowing exceptions silently | Failures become difficult to detect and diagnose. | Log, report, or otherwise handle errors meaningfully. |
Runnable when defining a task rather than extending Thread without a specific reason.run() method focused on the task's execution logic.Callable and Future when results or exception propagation are required.stop(), suspend(), and resume().GreetingTask that implements Runnable and prints a greeting message.Runnable class that prints numbers from 1 to 10.Runnable and prints the current thread name.Thread.sleep() and handles interruption correctly.Runnable tasks to an ExecutorService and shut the executor down properly.Runnable and extending Thread.Answer: Runnable is a functional interface in java.lang that defines the run() method. It represents a task that can be executed by a thread and does not return a result.
Answer: It separates task logic from thread management and allows the implementing class to extend another class. It also supports task reuse with thread pools and executor services.
Answer: No. Implementing Runnable defines the task. A new thread can be created by passing the task to a Thread object and calling start(), or the task can be submitted to an executor.
Answer: The run() method contains the code that should execute when the task is run. When a thread with a Runnable target is started, that thread invokes the target's run() method.
Answer: It behaves like an ordinary method call and executes on the calling thread. It does not start a new thread.
Answer: Yes. Runnable is a functional interface with one abstract method, so a lambda expression can provide its implementation.
Answer: Yes. Multiple thread objects can use the same Runnable instance. If the task shares or modifies mutable state, that state must be managed safely.
Answer: No. Its return type is void. Use Callable<V> when a task needs to return a value.
Answer: An executor accepts Runnable tasks and schedules them for execution, often using a pool of reusable worker threads. This separates task submission from thread management.
Answer: No. Thread safety depends on the task implementation and the data it accesses. Shared mutable state may require synchronization or other concurrency controls.
Runnable belongs to the java.lang package.void run().Thread constructor and call start() to execute it on a new thread.run() directly does not create a new thread.Callable when a task needs to return a result.ExecutorService for managing multiple tasks.The Runnable interface is a fundamental part of Java multithreading. It provides a simple way to define a task independently from the thread that executes it. By implementing run() and passing the task to a Thread or an executor service, developers can build reusable and maintainable concurrent applications.
Remember that implementing Runnable does not automatically create a new thread or guarantee thread safety. Correct use of start(), appropriate coordination, interruption handling, and protection of shared data are essential for reliable multithreaded programming.
Continue learning with the Core Java Training Course, register for a course demo, or visit the JustAcademy website.
